package org.example.cloudphoto.manager.lock;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class LocalLockManager {

    // 内部锁容器
    private static final Map<String, Object> lockMap = new ConcurrentHashMap<>();

    /**
     * 获取指定 key 的锁对象（懒加载）
     */
    private static Object getLock(String key) {
        return lockMap.computeIfAbsent(key, k -> new Object());
    }

    /**
     * 执行带锁的操作（同步执行）
     *
     * @param key   锁的 key（建议格式化清晰如 "lock:user:123"）
     * @param task  要执行的任务
     */
    public static void runWithLock(String key, Runnable task) {
        Object lock = getLock(key);
        synchronized (lock) {
            try {
                task.run();
            } finally {
                // 释放锁引用（非强制，防止内存膨胀，可选做）
                cleanupLock(key, lock);
            }
        }
    }

    /**
     * 执行带锁的操作（返回结果）
     */
    public static <T> T callWithLock(String key, java.util.concurrent.Callable<T> task) throws Exception {
        Object lock = getLock(key);
        synchronized (lock) {
            try {
                return task.call();
            } finally {
                cleanupLock(key, lock);
            }
        }
    }

    /**
     * 清理锁引用，避免锁对象过多（可选）
     */
    private static void cleanupLock(String key, Object lock) {
        // 只有当当前锁对象和 Map 中一致时才移除，避免误删
        lockMap.computeIfPresent(key, (k, v) -> v == lock ? null : v);
    }
}
